// profile.js
const defaultAvatarUrl = '/assets/images/wxlogo.png'
const api = require('../../utils/api')
const toast = require('../../utils/toast')
const request = require('../../utils/request')
const { IMG_URL } = require('../../utils/request'); // 引入IMG_URL

Page({
  data: {
    userInfo: {
      avatarUrl: defaultAvatarUrl,
      nickName: '未登录',
      uid: ''
    },
    tempUserInfo: {
      avatarUrl: defaultAvatarUrl,
      nickName: '',
      uid: ''
    },
    hasUserInfo: false,
    canIUseGetUserProfile: wx.canIUse('getUserProfile'),
    canIUseNicknameComp: wx.canIUse('input.type.nickname'),
  
    showLoginModal: false,
    IMG_URL: IMG_URL, // 添加IMG_URL到data中
    defaultAvatarUrl: defaultAvatarUrl // 添加默认头像URL到data中
  },
  
  onLoad() {
    // 获取全局app实例
    const app = getApp()
    
    // 尝试从本地存储获取用户信息
    const userInfo = wx.getStorageSync('userInfo')
    if (userInfo) {
      // 检查是否有displayAvatarUrl，如果没有则生成
      if (!userInfo.displayAvatarUrl && userInfo.avatarUrl) {
        userInfo.displayAvatarUrl = IMG_URL + userInfo.avatarUrl;
      }
      
      this.setData({
        userInfo: userInfo,
        hasUserInfo: true,
        })
    }
    
    // 判断全局登录状态
    if (app.globalData.isLoggedIn) {
      // 已登录，直接获取用户信息
      this.fetchUserInfo()
    } else {
      // 设置登录回调，登录成功后获取用户信息
      app.loginCallback = (isLoggedIn) => {
        if (isLoggedIn) {
          this.fetchUserInfo()
        }
      }
    }
  },
  
  onShow() {
    // 更新tabBar选中状态
    if (typeof this.getTabBar === 'function' && this.getTabBar()) {
      this.getTabBar().setData({
        selected: 1
      })
    }

    const app = getApp();
    if (app.globalData.showLoginModal) {
      this.showLoginModal();
      app.globalData.showLoginModal = false; // Reset the flag
    }
  },
  
  // 从服务器获取用户信息
  fetchUserInfo() {
    // 检查是否有登录态
    const token = wx.getStorageSync('token')
    if (!token) return
    
    // 使用API接口获取用户信息
    api.user.getUserInfo().then(data => {
      if (data) {
        console.log('[fetchUserInfo] 获取用户信息成功:', data);
        
        // 获取用于显示的头像URL
        const serverAvatarUrl = data.avatarUrl || '';
        const displayAvatarUrl = serverAvatarUrl ? (IMG_URL + serverAvatarUrl) : defaultAvatarUrl;
        console.log('[fetchUserInfo] 头像显示URL:', displayAvatarUrl);
        
        this.setData({
          userInfo: {
            avatarUrl: serverAvatarUrl, // 保存服务端返回的相对路径
            displayAvatarUrl: displayAvatarUrl, // 添加用于显示的完整URL
            nickName: data.nickName || '用户',
            uid: data.uid || ''
          },
          hasUserInfo: true
          })
        
        // 更新本地存储
        wx.setStorageSync('userInfo', this.data.userInfo)
      }
    }).catch(err => {
      console.error('获取用户信息失败', err)
    })
  },
  
  // 显示登录模态框
  showLoginModal() {
    // 如果已经登录，则不显示模态框
    if (this.data.hasUserInfo && this.data.userInfo.uid) {
      return;
    }

    // 如果已经登录，复制当前用户信息到临时变量
    if (this.data.hasUserInfo) {
      this.setData({
        tempUserInfo: {
          avatarUrl: this.data.userInfo.avatarUrl, // 保存相对路径
          nickName: this.data.userInfo.nickName,
          uid: this.data.userInfo.uid
        }
      })
    } else {
      // 如果未登录，使用默认值
      this.setData({
        tempUserInfo: {
          avatarUrl: defaultAvatarUrl,
          nickName: '',
          uid: ''
        }
      })
    }
    
    this.setData({
      showLoginModal: true
    })
    
    // 动态设置导航栏的层级
    wx.setTabBarStyle({
      zIndex: 1
    })
  },
  
  // 隐藏登录模态框
  hideLoginModal() {
    this.setData({
      showLoginModal: false
    })
    
    // 恢复导航栏的层级
    wx.setTabBarStyle({
      zIndex: 10
    })
  },
  
  // 阻止事件冒泡
  stopPropagation(e) {
    // 阻止点击事件冒泡
    return false
  },
  
  // 选择头像 - 最终解决方案
  onChooseAvatar(e) {
    const { avatarUrl } = e.detail
    if (!avatarUrl) {
      console.error('chooseAvatar failed, no avatarUrl received.');
      wx.showToast({ title: '选择头像失败', icon: 'none' });
      return;
    }
    
    console.log('步骤1: 收到原始头像路径:', avatarUrl);

    wx.showLoading({ title: '头像处理中...', mask: true });

    // 步骤2: 调用 compressImage "清洗"路径，获取可靠的临时文件
    wx.compressImage({
      src: avatarUrl,
      quality: 80, // 压缩质量
      success: (res) => {
        const reliablePath = res.tempFilePath;
        console.log('步骤2: 路径清洗成功，获得新的可靠路径:', reliablePath);
        
        // 步骤3: 使用新的、可靠的路径进行上传
        wx.uploadFile({
          url: request.BASE_URL + '/uploadAvatar',
          filePath: reliablePath,
          name: 'file',
          formData: { openId: wx.getStorageSync('openId') || '' },
          success: (uploadRes) => {
            wx.hideLoading();
            try {
              const data = JSON.parse(uploadRes.data);
              if (data && data.code === 200 && data.data) {
                // 只保存相对路径，不带上IMG_URL
                const imagePath = data.data;
                console.log('步骤4: 上传成功，保存相对路径:', imagePath);
                
                // 为了显示，仍然使用完整URL
                const fullImageUrl = IMG_URL + imagePath;
                console.log('用于显示的完整URL:', fullImageUrl);
                
                // 在tempUserInfo中保存相对路径
                this.setData({ 'tempUserInfo.avatarUrl': imagePath });
              } else {
                console.error('上传接口返回错误或数据格式不正确:', data);
                wx.showToast({ title: '上传失败[接口异常]', icon: 'none' });
              }
            } catch (err) {
              console.error('解析上传接口返回数据失败:', err);
              wx.showToast({ title: '上传失败[数据解析失败]', icon: 'none' });
            }
          },
          fail: (uploadErr) => {
            wx.hideLoading();
            console.error('步骤3: wx.uploadFile 接口调用失败:', uploadErr);
            wx.showToast({ title: '上传失败[网络错误]', icon: 'none' });
          }
        });
      },
      fail: (compressErr) => {
        wx.hideLoading();
        console.error('步骤2: wx.compressImage 路径清洗失败:', compressErr);
        wx.showToast({ title: '处理头像失败', icon: 'none' });
      }
    });
  },
  
  // 输入昵称
  onNicknameInput(e) {
    const nickName = e.detail.value
    this.setData({
      'tempUserInfo.nickName': nickName
    })
  },
  
  // 保存用户信息
  saveUserInfo() {
    if (!this.data.tempUserInfo.nickName.trim()) {
      wx.showToast({
        title: '请输入昵称',
        icon: 'none'
      })
      return
    }
    
    // 显示加载中
    wx.showLoading({
      title: '登录中...',
      mask: true
    })
    
    // 生成随机UID
    const uid = this.data.tempUserInfo.uid || this.generateUID()
    
    // 判断头像是否是默认头像，如果是则不传
    const avatarUrl = this.data.tempUserInfo.avatarUrl === defaultAvatarUrl ? '' : this.data.tempUserInfo.avatarUrl;
    
    const userInfo = {
      avatarUrl: avatarUrl, // 不使用默认值，只保存相对路径
      nickName: this.data.tempUserInfo.nickName,
      uid: uid
    }
    
    // 获取用于显示的头像URL
    const displayAvatarUrl = userInfo.avatarUrl ? (IMG_URL + userInfo.avatarUrl) : defaultAvatarUrl;
    
    // 先更新本地UI状态，优化用户体验
    this.setData({
      userInfo: {
        ...userInfo,
        displayAvatarUrl: displayAvatarUrl // 界面显示时使用完整URL或默认头像
      },
      hasUserInfo: true,
      showLoginModal: false
    })
    
    // 调用微信登录
    this.doLoginWithServer(userInfo)
  },
  
  // 微信登录
  wxLogin(userInfo) {
    // 先保存用户信息到本地，以便app.js中的全局登录方法使用
    wx.setStorageSync('userInfo', userInfo)
    
    // 直接调用登录接口
      this.doLoginWithServer(userInfo)
  },

  // 调用服务端登录接口
  doLoginWithServer(userInfo) {
    // 显示加载中
    wx.showLoading({
      title: '登录中...',
      mask: true
    })
    
    // 获取微信登录凭证
    wx.login({
      success: res => {
        if (res.code) {
          // 发送登录请求，直接传递code、avatarUrl和nickName参数
          api.user.wxLogin({
            code: res.code,
            avatarUrl: userInfo.avatarUrl, // 不添加默认值，如果为空则传空
            nickName: userInfo.nickName || ''
          })
          .then(result => {
            console.log('[登录流程] 登录接口调用成功，服务器返回:', result);
            
            // 服务端返回的数据已经是data字段的内容
            const serverData = result;
            console.log('[登录流程] 处理后的数据:', serverData);
            
            // 使用服务端返回的数据
            const serverAvatarUrl = serverData.avatarUrl || '';
            console.log('[登录流程] 服务端返回的头像URL:', serverAvatarUrl);
            
              const updatedUserInfo = {
              nickName: serverData.nickName || userInfo.nickName,
              avatarUrl: serverAvatarUrl, // 使用服务端返回的头像URL
              uid: serverData.id,
              openId: serverData.openId,
             
            };
            
            // 获取用于显示的头像URL
            const displayAvatarUrl = serverAvatarUrl ? (IMG_URL + serverAvatarUrl) : defaultAvatarUrl;
            console.log('[登录流程] 头像显示URL:', displayAvatarUrl);
            
            // 存储凭证(openId)的操作已在request.js中自动完成
            console.log('[登录流程] 准备更新本地缓存中的userInfo');
            
            // 更新用户信息
            wx.setStorageSync('userInfo', {
              ...updatedUserInfo,
              displayAvatarUrl: displayAvatarUrl // 本地存储时添加显示用的完整URL
            });
            console.log('[登录流程] userInfo更新完毕');
            
            // 更新全局登录状态
            const app = getApp()
            app.globalData.isLoggedIn = true
            app.globalData.userInfo = {
              ...updatedUserInfo,
              displayAvatarUrl: displayAvatarUrl // 全局数据使用完整URL
            }
            
            this.setData({
              userInfo: {
                ...updatedUserInfo,
                displayAvatarUrl: displayAvatarUrl // 界面显示使用完整URL
              },
              hasUserInfo: true
            });

            // 登录成功回调
            if (app.loginCallback) {
              app.loginCallback(true)
            }
            
            wx.showToast({
              title: '登录成功',
              icon: 'success'
            })
          })
          .catch(err => {
            console.error('登录失败', err)
            // 错误提示已在request.js中统一处理
            
            // 更新全局登录状态
            const app = getApp()
            app.globalData.isLoggedIn = false
            
            if (app.loginCallback) {
              app.loginCallback(false)
            }
          })
          .finally(() => {
            wx.hideLoading()
          })
        } else {
          console.error('获取微信登录凭证失败', res)
          wx.showToast({
            title: '登录失败，请重试',
            icon: 'none'
          })
          wx.hideLoading()
        }
      },
      fail: err => {
        console.error('wx.login调用失败', err)
        wx.showToast({
          title: '登录失败，请重试',
          icon: 'none'
        })
        wx.hideLoading()
      }
    })
  },
  
  // 更新用户信息到服务器
  updateUserInfo(userInfo) {
    api.user.updateUserInfo({
      nickName: userInfo.nickName,
      uid: userInfo.uid
    }).then(res => {
      wx.showToast({
        title: '保存成功',
        icon: 'success'
      })
    }).catch(err => {
      console.error('更新用户信息失败', err)
      // 仍然显示保存成功，因为本地已经保存
      wx.showToast({
        title: '已保存到本地',
        icon: 'success'
      })
    })
  },
  
  // 生成随机UID
  generateUID() {
    return Math.floor(10000000 + Math.random() * 90000000).toString()
  },
  
  // 获取当前日期格式化为 YYYY.MM.DD
  getCurrentDate() {
    const date = new Date()
    const year = date.getFullYear()
    const month = (date.getMonth() + 1).toString().padStart(2, '0')
    const day = date.getDate().toString().padStart(2, '0')
    return `${year}.${month}.${day}`
  },
  
  // 我发起的页面
  goToOrders() {
    // 判断用户是否登录
    const openId = wx.getStorageSync('openId');
    if (!openId) {
      this.showLoginModal();
      return;
    }
    
    // 跳转到我的文档页面，并传递type=create参数表示查看"我发起的"文档
    wx.navigateTo({
      url: '/pages/my-documents/my-documents?type=create'
    });
  },
  
  // 我参与的页面
  goToFavorites() {
    // 判断用户是否登录
    const openId = wx.getStorageSync('openId');
    if (!openId) {
      this.showLoginModal();
      return;
    }
    
    // 跳转到我的文档页面，并传递type=participate参数表示查看"我参与的"文档
    wx.navigateTo({
      url: '/pages/my-documents/my-documents?type=participate'
    });
  },
  
  // 查看所有足迹
  viewAllFootprints() {
    wx.showToast({
      title: '足迹功能开发中',
      icon: 'none'
    })
  },
  
  goToSettings() {
    wx.showToast({
      title: '设置功能开发中',
      icon: 'none'
    })
  },
  
  goToAbout() {
    wx.navigateTo({
      url: '/pages/about/about'
    });
  }
}) 